#include "pad.h"


//--------------------------------------------------------------------------------------------/

pad::pad(SDL_Surface* buffer) :	figura("pad"), ancho(1), alto(1), bufferSurface(buffer)
{
	this->ubicacionNueva.w = 1;
	this->ubicacionNueva.h = 1;
	this->ubicacionNueva.x = 1;
	this->ubicacionNueva.y = 1;


	colorBordeGrafico = NULL;

	colorRellenoGrafico = NULL;

	tex = NULL;


}

//--------------------------------------------------------------------------------------------/


pad::pad(punto puntoInicial, double width, double height, SDL_Surface* buffer) :
	figura("pad"), puntoInicial(puntoInicial), ancho(width), alto(height),bufferSurface(buffer)
{
	this->ubicacionNueva.w = (int) (pasajeEntero(width*2, 1)	)+1;
	this->ubicacionNueva.h = (int) (pasajeEntero(height, 1))+1;    //h*2
	this->ubicacionNueva.x = (int) (pasajeEntero(puntoInicial.getX(), 1) ) ; //0;
	this->ubicacionNueva.y = (int) (pasajeEntero(getPInicial().getY(), 1) );

	colorBordeGrafico = NULL;

	colorRellenoGrafico = NULL;

	tex = NULL;
}


//--------------------------------------------------------------------------------------------/

void pad::clear() {
SDL_Surface* screen = pantalla::getPantalla();

//	SDL_BlitSurface(this->bufferSurface, &this->ubicacionNueva, screen,	&this->ubicacionNueva);



	/* BORRA RASTRO DE PAD 1 */
					punto centro_pad;

					SDL_Rect offset;


					centro_pad = this->getPInicial();
					
					offset.x = centro_pad.getX();
					offset.y = 0;
					offset.h = centro_pad.getY();
					offset.w = this->getAncho();

					SDL_BlitSurface(this->bufferSurface,&offset,screen,&offset);
	

					offset.x = centro_pad.getX();
					offset.y = centro_pad.getY()+this->getAlto();
					offset.h = screen->h;
					offset.w = this->getAncho();

					SDL_BlitSurface(this->bufferSurface,&offset,screen,&offset);
	
			




}

//--------------------------------------------------------------------------------------------/

//NO USAR DEL LADO SERVER
void pad::setPInicial(punto pInicial) {
	this->clear();//CLAUDIO
	this->puntoInicial = pInicial;
	this->ubicacionNueva.y = (int) (pasajeEntero( this->puntoInicial.getY(), 1));
}
//--------------------------------------------------------------------------------------------/

void pad::setAncho(double width) {
	this->ancho = width;
}
//--------------------------------------------------------------------------------------------/

void pad::setAlto(double height) {
	this->alto = height;
}
//--------------------------------------------------------------------------------------------/

punto& pad::getPInicial() {
	return puntoInicial;
}
//--------------------------------------------------------------------------------------------/

double pad::getAncho() {
	return ancho;
}
//--------------------------------------------------------------------------------------------/

double pad::getAlto() {
	return alto;
}


//--------------------------------------------------------------------------------------------/



/*void graficarLineaRectangulo(SDL_Surface* screen, punto puntoInicial, punto puntoFinal,color color)
{
	punto unPunto;
	int errorEnX,errorEnY, tamanio, cantidad,
	VerX, VerY, xInicial, yInicial, xFinal, yFinal,diferencialX, diferencialY;

	xInicial = (int)puntoInicial.getX();
	xFinal = (int)puntoFinal.getX();
	yInicial = (int)puntoInicial.getY();
	yFinal =(int) puntoFinal.getY();

	diferencialX = xFinal - xInicial;
	diferencialY = yFinal - yInicial;

	if (diferencialX > 0)
		VerX = 1;
	else if (diferencialX == 0)
		VerX = 0;
	else
		VerX = -1;

	if (diferencialY > 0)
		VerY = 1;
	else if (diferencialY == 0)
		VerY = 0;
	else
		VerY = -1;

	diferencialX = abs(diferencialX);
	diferencialY = abs(diferencialY);

	if (diferencialX > diferencialY)
		tamanio = diferencialX;
	else
		tamanio = diferencialY;

	errorEnX = 0;
	errorEnY = 0;

	for (cantidad = 0; cantidad <= tamanio+1; cantidad++)
	{

		unPunto.ponerUnPixel(screen, xInicial, yInicial, color);

		errorEnX =errorEnX + diferencialX;
		errorEnY =errorEnY + diferencialY;

		if (errorEnX > tamanio)
		{
			xInicial = xInicial + VerX;
			errorEnX =errorEnX - tamanio;

		}
		if (errorEnY > tamanio)
		{
			yInicial = yInicial + VerY;
			errorEnY =errorEnY- tamanio;

		}
	}
}
*/
//--------------------------------------------------------------------------------------------/


void pad::graficarRellenoRectangulo()
{
	SDL_Surface* screen = pantalla::getPantalla();

	//rellena un rectangulo
	SDL_Rect rellenoRectangulo;
	Uint32 colorRellenoFigura=SDL_MapRGB(screen->format, colorRellenoGrafico->getRojo(),colorRellenoGrafico->getVerde(), colorRellenoGrafico->getAzul());
	rellenoRectangulo.x=(int)puntoInicial.getX();
	rellenoRectangulo.y=(int)puntoInicial.getY();
	rellenoRectangulo.h=(int)alto;
	rellenoRectangulo.w=(int)ancho;
	SDL_FillRect(screen,&rellenoRectangulo,colorRellenoFigura);
	SDL_UpdateRect(screen,rellenoRectangulo.x,rellenoRectangulo.y,rellenoRectangulo.w,rellenoRectangulo.h);
}
//--------------------------------------------------------------------------------------------/

void pad::graficarpad()
{
	SDL_Surface* screen = pantalla::getPantalla();

	graficarRellenoRectangulo();

	punto desde,hasta;

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY()+alto);
	hasta.setX(puntoInicial.getX());
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY());
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX()+ancho);
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY()+alto );
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY()+alto);
	hasta.setY(puntoInicial.getY()+alto);
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

}

//--------------------------------------------------------------------------------------------/


void pad::graficar(bool actualizarLogicamente) {
	//this->ubicacionNueva.x = (int) (pasajeEntero(this->pCentro.getX()- getRadioX(), 1) );
	this->ubicacionNueva.x = (int) (pasajeEntero(this->puntoInicial.getX(), 1) ) ; //0;

	this->clear();
	if (!actualizarLogicamente) {
		this->graficarRellenoRectangulo();
		this->graficarpad();
	}

}
//--------------------------------------------------------------------------------------------/

void pad::graficar(){
	this->graficar(false);
}


//--------------------------------------------------------------------------------------------/
void pad::desplazamientoArriba() {

	//ESTO PARA QUE NO SE VAYA DE RANGO EL PAD,
	// O SEA QUE NO SUPERE EL TECHO DE LA PANTALLA

	if (this->getPInicial().getY()+ this->alto > 145)
	{
		punto nuevoPunto = this->getPInicial();

		 //ESTE VALOR "-10" ACTUA COMO VELOCIDAD DEL PAD, PORQUE  SI AUMENTA,
		//ESTOY DIBUJANDO MAS PARA ARRIBA AL PAD, PARA LA VELOCIDAD CREO QUE PODRIA IR ESTO LUEGO DE COMER EL BONUS DE VELOCIDAD

		nuevoPunto.setY(nuevoPunto.getY()-15);

		//LUEGO LO SETEO PARA QUE DIBUJE LA NUEVA POSICION
		this->getPInicial().setX(nuevoPunto.getX());
		this->getPInicial().setY(nuevoPunto.getY());
	}
}

//--------------------------------------------------------------------------------------------/
void pad::desplazamientoAbajo() {

	//ESTO PARA QUE NO SE VAYA DE RANGO EL PAD,
	// O SEA QUE NO SUPERE EL TECHO DE LA PANTALLA

	if (this->getPInicial().getY()+ this->alto < 480)
	{
		punto nuevoPunto = this->getPInicial();

		 //ESTE VALOR "-10" ACTUA COMO VELOCIDAD DEL PAD, PORQUE  SI AUMENTA,
		//ESTOY DIBUJANDO MAS PARA ARRIBA AL PAD, PARA LA VELOCIDAD CREO QUE PODRIA IR ESTO LUEGO DE COMER EL BONUS DE VELOCIDAD

		nuevoPunto.setY(nuevoPunto.getY()+15);

		//LUEGO LO SETEO PARA QUE DIBUJE LA NUEVA POSICION
		this->getPInicial().setX(nuevoPunto.getX());
		this->getPInicial().setY(nuevoPunto.getY());
	}
}


//--------------------------------------------------------------------------------------------/


void pad::algoritmoGraficar()
{
	SDL_Surface* screen = pantalla::getPantalla();
	graficarRellenoRectangulo();

	punto desde,hasta;

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY()+alto);
	hasta.setX(puntoInicial.getX());
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY());
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX()+ancho);
	desde.setY(puntoInicial.getY());
	hasta.setY(puntoInicial.getY()+alto );
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);

	desde.setX(puntoInicial.getX());
	desde.setY(puntoInicial.getY()+alto);
	hasta.setY(puntoInicial.getY()+alto);
	hasta.setX(puntoInicial.getX()+ancho);
//	graficarLineaRectangulo(screen,hasta,desde,*colorBordeGrafico);
}

//--------------------------------------------------------------------------------------------/

pad::~pad()
{
//tener cuidado, por ahi es problema
/*	if 	(colorBordeGrafico != NULL) {delete colorBordeGrafico;}

	if (colorRellenoGrafico != NULL) {delete colorRellenoGrafico;}

	if (tex != NULL) {delete tex;}
*/

}
//--------------------------------------------------------------------------------------------/


